﻿using System.Data;
using 名词表;

namespace 战斗系统原型.数据导入导出
{
    internal static class 数据序列化
    {
        public static void 序列化角色基础数据(Dictionary<string, DataTable> 原数据, int 读取等级, Dictionary<string, 角色> 人物数据组)
        {
            foreach (var 数据 in 原数据)
            {
                string 角色名称 = 数据.Key;
                DataTable 表 = 数据.Value;
                攻击属性 角色属性 = (攻击属性)Enum.Parse(typeof(攻击属性), 表.Rows[读取等级]["角色属性"].ToString()!);
                float 等级 = 读取等级;
                float 生命值 = float.Parse(表.Rows[读取等级]["生命值上限"].ToString()!);
                float 符力值 = float.Parse(表.Rows[读取等级]["符力值上限"].ToString()!);
                int 怒气值 = int.Parse(表.Rows[读取等级]["怒气值上限"].ToString()!);
                float 生命值上限 = float.Parse(表.Rows[读取等级]["生命值上限"].ToString()!);
                float 符力值上限 = float.Parse(表.Rows[读取等级]["符力值上限"].ToString()!);
                float 怒气值上限 = int.Parse(表.Rows[读取等级]["怒气值上限"].ToString()!);
                float 生命值上限附加 = 0;
                float 符力值上限附加 = 0;
                float 爆击率 = float.Parse(表.Rows[读取等级]["爆击率"].ToString()!);
                float 物防力 = float.Parse(表.Rows[读取等级]["物防力"].ToString()!);
                float 符防力 = float.Parse(表.Rows[读取等级]["符防力"].ToString()!);
                float 基础物攻 = float.Parse(表.Rows[读取等级]["基础物攻"].ToString()!);
                float 爆击率附加 = 0;
                float 物防力附加 = 0;
                float 符防力附加 = 0;
                float 基础物攻附加 = 0;
                float 物攻最低 = 基础数值计算.减少百分比(基础物攻 + 基础物攻附加, float.Parse(表.Rows[读取等级]["物攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 物攻最高 = 基础数值计算.增加百分比(基础物攻 + 基础物攻附加, float.Parse(表.Rows[读取等级]["物攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 基础符攻 = float.Parse(表.Rows[读取等级]["基础符攻"].ToString()!);
                float 基础符攻附加 = 0;
                float 符攻最低 = 基础数值计算.减少百分比(基础符攻 + 基础符攻附加, float.Parse(表.Rows[读取等级]["符攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 符攻最高 = 基础数值计算.增加百分比(基础符攻 + 基础符攻附加, float.Parse(表.Rows[读取等级]["符攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 速度 = float.Parse(表.Rows[读取等级]["速度"].ToString()!);
                float 速度附加 = 0;
                List<int> 技能ID = new List<int>();
                float 经验值上限 = float.Parse(表.Rows[读取等级]["经验值上限"].ToString()!);
                bool 技能全体化 = false;
                bool 物品全体化 = false;
                bool 御守全体化 = false;
                bool 流血 = false;
                bool 灼烧 = false;
                bool 麻痹 = false;
                角色 人物 = new 角色()
                {
                    等级 = 等级,
                    角色名称 = 角色名称,
                    角色属性 = 角色属性,
                    生命值 = 生命值,
                    生命值上限 = 生命值上限,
                    生命值上限附加 = 生命值上限附加,
                    符力值 = 符力值,
                    符力值上限 = 符力值上限,
                    符力值上限附加 = 符力值上限附加,
                    怒气值 = 怒气值,
                    怒气值上限 = 怒气值上限,
                    基础物攻 = 基础物攻,
                    基础物攻附加 = 基础物攻附加,
                    基础符攻 = 基础符攻,
                    基础符攻附加 = 基础符攻附加,
                    御守全体化 = 御守全体化,
                    技能ID = 技能ID,
                    技能全体化 = 技能全体化,
                    爆击率 = 爆击率,
                    爆击率附加 = 爆击率附加,
                    物品全体化 = 物品全体化,
                    物攻最低 = 物攻最低,
                    物攻最高 = 物攻最高,
                    物防力 = 物防力,
                    物防力附加 = 物防力附加,
                    符攻最低 = 符攻最低,
                    符攻最高 = 符攻最高,
                    符防力 = 符防力,
                    符防力附加 = 符防力附加,
                    经验值上限 = 经验值上限,
                    速度 = 速度,
                    速度附加 = 速度附加,
                    流血 = 流血,
                    灼烧 = 灼烧,
                    麻痹 = 麻痹,
                    操作模式 = 角色.操作者.玩家
                };
                人物数据组.Add(角色名称, 人物);
            }
        }
        public static void 序列化怪物基础数据(数据组 数据组, DataTable 原数据, Dictionary<string, 角色> 怪物数据组)
        {
            for (int 当前项 = 0; 当前项 < 原数据.Rows.Count; 当前项++)
            {
                string 角色名称 = 原数据.Rows[当前项]["角色名称"].ToString()!;
                攻击属性 角色属性 = (攻击属性)Enum.Parse(typeof(攻击属性), 原数据.Rows[当前项]["角色属性"].ToString()!);
                float 等级 = 当前项;
                float 生命值 = float.Parse(原数据.Rows[当前项]["生命值上限"].ToString()!);
                float 符力值 = float.Parse(原数据.Rows[当前项]["符力值上限"].ToString()!);
                int 怒气值 = int.Parse(原数据.Rows[当前项]["怒气值上限"].ToString()!);
                float 生命值上限 = float.Parse(原数据.Rows[当前项]["生命值上限"].ToString()!);
                float 符力值上限 = float.Parse(原数据.Rows[当前项]["符力值上限"].ToString()!);
                float 怒气值上限 = int.Parse(原数据.Rows[当前项]["怒气值上限"].ToString()!);
                float 生命值上限附加 = 0;
                float 符力值上限附加 = 0;
                float 爆击率 = float.Parse(原数据.Rows[当前项]["爆击率"].ToString()!);
                float 物防力 = float.Parse(原数据.Rows[当前项]["物防力"].ToString()!);
                float 符防力 = float.Parse(原数据.Rows[当前项]["符防力"].ToString()!);
                float 基础物攻 = float.Parse(原数据.Rows[当前项]["基础物攻"].ToString()!);
                int 掉落经验值 = int.Parse(原数据.Rows[当前项]["掉落经验值"].ToString()!);
                float 爆击率附加 = 0;
                float 物防力附加 = 0;
                float 符防力附加 = 0;
                float 基础物攻附加 = 0;
                float 物攻最低 = 基础数值计算.减少百分比(基础物攻 + 基础物攻附加, float.Parse(原数据.Rows[当前项]["物攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 物攻最高 = 基础数值计算.增加百分比(基础物攻 + 基础物攻附加, float.Parse(原数据.Rows[当前项]["物攻最高"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 基础符攻 = float.Parse(原数据.Rows[当前项]["基础符攻"].ToString()!);
                float 基础符攻附加 = 0;
                float 符攻最低 = 基础数值计算.减少百分比(基础符攻 + 基础符攻附加, float.Parse(原数据.Rows[当前项]["符攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 符攻最高 = 基础数值计算.增加百分比(基础符攻 + 基础符攻附加, float.Parse(原数据.Rows[当前项]["符攻最高"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
                float 速度 = float.Parse(原数据.Rows[当前项]["速度"].ToString()!);
                float 速度附加 = 0;
                List<int> 技能ID = new List<int>();
                //掉落物品序列化
                List<物品> 掉落物品 = new List<物品>();
                var 掉落物品ID文本 = 原数据.Rows[当前项]["掉落物品"].ToString()!;
                if (!string.IsNullOrWhiteSpace(掉落物品ID文本))
                {
                    var 掉落物品ID集 = 掉落物品ID文本.Split(',').ToList<string>();
                    foreach (var 物品ID in 掉落物品ID集)
                    {
                        int ID = int.Parse(物品ID);
                        var 待添加物品 = 数据组.物品数据.ElementAt(ID).Value;
                        掉落物品.Add(待添加物品);
                    }
                }

                float 掉落物品概率 = float.Parse(原数据.Rows[当前项]["掉落物品概率"].ToString()!);
                int 掉落金钱 = int.Parse(原数据.Rows[当前项]["掉落金钱"].ToString()!);
                bool 技能全体化 = false;
                bool 物品全体化 = false;
                bool 御守全体化 = false;
                bool 流血 = false;
                bool 灼烧 = false;
                bool 麻痹 = false;
                角色 人物 = new 角色()
                {
                    等级 = 等级,
                    角色名称 = 角色名称,
                    角色属性 = 角色属性,
                    生命值 = 生命值,
                    生命值上限 = 生命值上限,
                    生命值上限附加 = 生命值上限附加,
                    符力值 = 符力值,
                    符力值上限 = 符力值上限,
                    符力值上限附加 = 符力值上限附加,
                    怒气值 = 怒气值,
                    怒气值上限 = 怒气值上限,
                    基础物攻 = 基础物攻,
                    基础物攻附加 = 基础物攻附加,
                    基础符攻 = 基础符攻,
                    基础符攻附加 = 基础符攻附加,
                    御守全体化 = 御守全体化,
                    技能ID = 技能ID,
                    技能全体化 = 技能全体化,
                    爆击率 = 爆击率,
                    爆击率附加 = 爆击率附加,
                    物品全体化 = 物品全体化,
                    物攻最低 = 物攻最低,
                    物攻最高 = 物攻最高,
                    物防力 = 物防力,
                    物防力附加 = 物防力附加,
                    符攻最低 = 符攻最低,
                    符攻最高 = 符攻最高,
                    符防力 = 符防力,
                    符防力附加 = 符防力附加,
                    速度 = 速度,
                    速度附加 = 速度附加,
                    流血 = 流血,
                    灼烧 = 灼烧,
                    掉落物品 = 掉落物品,
                    掉落物品概率 = 掉落物品概率,
                    掉落金钱 = 掉落金钱,
                    掉落经验值 = 掉落经验值,
                    麻痹 = 麻痹,
                    操作模式 = 角色.操作者.AI
                };
                怪物数据组.Add(角色名称, 人物);
            }
        }
        public static void 序列化技能基础数据(数据组 数据组, DataTable 原数据, Dictionary<string, 技能> 技能数据组)
        {
            for (int 当前项 = 0; 当前项 < 原数据.Rows.Count; 当前项++)
            {
                int ID = int.Parse(原数据.Rows[当前项]["ID"].ToString()!);
                string 技能名称 = 原数据.Rows[当前项]["技能名称"].ToString()!;
                角色 兼容人物 = 数据组.人物数据.ElementAt(int.Parse(原数据.Rows[当前项]["兼容人物"].ToString()!)).Value;
                bool 对所有敌人兼容 = bool.Parse(原数据.Rows[当前项]["对所有敌人兼容"].ToString()!);
                技能类型 技能类型 = (技能类型)Enum.Parse(typeof(技能类型), 原数据.Rows[当前项]["技能类型"].ToString()!);
                作用对象 作用对象 = (作用对象)Enum.Parse(typeof(作用对象), 原数据.Rows[当前项]["作用对象"].ToString()!);
                攻击属性 伤害属性 = (攻击属性)Enum.Parse(typeof(攻击属性), 原数据.Rows[当前项]["攻击属性"].ToString()!);
                int 伤害次数 = 数值转换.文本转int数值(原数据.Rows[当前项]["伤害次数"].ToString()!);
                float 物攻加成 = 数值转换.文本转float数值(原数据.Rows[当前项]["物攻加成"].ToString()!);
                float 符攻加成 = 数值转换.文本转float数值(原数据.Rows[当前项]["符攻加成"].ToString()!);
                float 额外固定值 = 数值转换.文本转float数值(原数据.Rows[当前项]["额外固定值"].ToString()!);
                string 物品栏概述 = 原数据.Rows[当前项]["物品栏概述"].ToString()!;
                string 战斗时概述 = 原数据.Rows[当前项]["战斗时概述"].ToString()!;
                //List <效果> 效果列 = 原数据.Rows[当前项]["效果列"].ToString()!;
                技能 技能 = new()
                {
                    ID = ID,
                    技能名称 = 技能名称,
                    兼容人物 = 兼容人物,
                    对所有敌人兼容 = 对所有敌人兼容,
                    技能类型 = 技能类型,
                    作用对象 = 作用对象,
                    伤害属性 = 伤害属性,
                    伤害次数 = 伤害次数,
                    物攻加成 = 物攻加成,
                    符攻加成 = 符攻加成,
                    额外固定值 = 额外固定值,
                    //效果列 = 效果列,
                    //计数消耗 = 计数消耗,
                    物品栏概述 = 物品栏概述,
                    战斗时概述 = 战斗时概述,
                };
                数据组.技能数据.Add(技能.技能名称, 技能);
            }
        }
        public static void 更新角色等级基础数据(数据组 数据组, 主角团姓名 角色名称, int 读取等级, float 基础物攻附加 = 0, float 基础符攻附加 = 0)
        {
            //从数据库中读取数据集
            var 表 = 数据组.角色数值表[角色名称.ToString()];
            var 人物数据 = 数据组.人物数据[角色名称.ToString()];
            攻击属性 角色属性 = (攻击属性)Enum.Parse(typeof(攻击属性), 表.Rows[读取等级]["角色属性"].ToString()!);
            float 等级 = 读取等级;
            float 生命值 = float.Parse(表.Rows[读取等级]["生命值上限"].ToString()!);
            float 符力值 = float.Parse(表.Rows[读取等级]["符力值上限"].ToString()!);
            int 怒气值 = int.Parse(表.Rows[读取等级]["怒气值上限"].ToString()!);
            float 生命值上限 = float.Parse(表.Rows[读取等级]["生命值上限"].ToString()!);
            float 符力值上限 = float.Parse(表.Rows[读取等级]["符力值上限"].ToString()!);
            float 怒气值上限 = int.Parse(表.Rows[读取等级]["怒气值上限"].ToString()!);
            float 爆击率 = float.Parse(表.Rows[读取等级]["爆击率"].ToString()!);
            float 物防力 = float.Parse(表.Rows[读取等级]["物防力"].ToString()!);
            float 符防力 = float.Parse(表.Rows[读取等级]["符防力"].ToString()!);
            float 基础物攻 = float.Parse(表.Rows[读取等级]["基础物攻"].ToString()!);
            float 物攻最低 = 基础数值计算.减少百分比(基础物攻 + 基础物攻附加, float.Parse(表.Rows[读取等级]["物攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
            float 物攻最高 = 基础数值计算.增加百分比(基础物攻 + 基础物攻附加, float.Parse(表.Rows[读取等级]["物攻最高"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
            float 基础符攻 = float.Parse(表.Rows[读取等级]["基础符攻"].ToString()!);
            float 符攻最低 = 基础数值计算.减少百分比(基础符攻 + 基础符攻附加, float.Parse(表.Rows[读取等级]["符攻最低"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
            float 符攻最高 = 基础数值计算.增加百分比(基础符攻 + 基础符攻附加, float.Parse(表.Rows[读取等级]["符攻最高"].ToString()!.Split('%').FirstOrDefault()!)).最终值;
            float 速度 = float.Parse(表.Rows[读取等级]["速度"].ToString()!);
            List<int> 技能ID = new List<int>();
            float 经验值上限 = float.Parse(表.Rows[读取等级]["经验值上限"].ToString()!);

            //更新人物数据到数据集
            人物数据.等级 = 等级;
            人物数据.角色名称 = 角色名称.ToString();
            人物数据.角色属性 = 角色属性;
            人物数据.生命值 = 生命值;
            人物数据.生命值上限 = 生命值上限;
            人物数据.符力值 = 符力值;
            人物数据.符力值上限 = 符力值上限;
            人物数据.怒气值 = 怒气值;
            人物数据.怒气值上限 = 怒气值上限;
            人物数据.基础物攻 = 基础物攻;
            人物数据.基础物攻附加 = 基础物攻附加;
            人物数据.基础符攻 = 基础符攻;
            人物数据.基础符攻附加 = 基础符攻附加;
            人物数据.技能ID = 技能ID;
            人物数据.爆击率 = 爆击率;
            人物数据.物攻最低 = 物攻最低;
            人物数据.物攻最高 = 物攻最高;
            人物数据.物防力 = 物防力;
            人物数据.符攻最低 = 符攻最低;
            人物数据.符攻最高 = 符攻最高;
            人物数据.符防力 = 符防力;
            人物数据.经验值上限 = 经验值上限;
            人物数据.速度 = 速度;



        }
        public static void 从文件读取实体数据(数据组 数据组, string 文件路径)
        {
            MiniExcel辅助类 Excel = new MiniExcel辅助类(文件路径);
            //读取我方角色数据
            var 主角配置 = Excel.从Excel转DataTable(名词表.配置文件名词.玩家主要控制角色, true);
            var 第二主角配置 = Excel.从Excel转DataTable(名词表.配置文件名词.第二主角, true);
            数据组.角色数值表.Add(名词表.配置文件名词.名词转换表[主角配置.TableName], 主角配置);
            数据组.角色数值表.Add(名词表.配置文件名词.名词转换表[第二主角配置.TableName], 第二主角配置);
            数据导入导出.数据序列化.序列化角色基础数据(数据组.角色数值表, 1, 数据组.人物数据);
            //读取敌方角色数据
            var 敌方角色配置 = Excel.从Excel转DataTable("地图怪物", true);
            数据导入导出.数据序列化.序列化怪物基础数据(数据组, 敌方角色配置, 数据组.敌人数据);
            //读取我方技能数据
            var 技能配置 = Excel.从Excel转DataTable("技能表", true);
            数据导入导出.数据序列化.序列化技能基础数据(数据组, 技能配置, 数据组.技能数据);

        }
        public static void 读取队伍数据(数据组 数据组)
        {
            数据组.队伍数据.Add(队伍类型.我方队伍, new 队伍()
            {
                队伍名称 = 队伍类型.我方队伍.ToString(),
                物品列表 = new List<物品>(),
                队伍成员 = new List<角色>() {
                    数据组.人物数据.ElementAt(0).Value,
                    //数据组.人物数据.ElementAt(1).Value
                },
                队伍金钱 = 0
            });
            数据组.队伍数据.Add(队伍类型.敌方队伍, new 队伍()
            {
                队伍名称 = 队伍类型.敌方队伍.ToString(),
                物品列表 = new List<物品>(),
                队伍成员 = new List<角色>() { 数据组.敌人数据.ElementAt(0).Value },
                队伍金钱 = 0
            });
        }
    }
}
